﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using System.Windows.Input;
using System.Collections.Specialized;
using produccion.reportes;
using Excel = Microsoft.Office.Interop.Excel;



namespace produccion.vistamodelo
{
    class VMInventarioFisico : ViewModelBase, IDataErrorInfo
    {
        
        #region Campos

            private Int32 numTipo = 1;

            private List<CLSMAEGRP> _grupos = new List<CLSMAEGRP>();
            private CLSMAEGRP _selgrupo = new CLSMAEGRP();

            private List<CLSMAESUB> _subgrupos = new List<CLSMAESUB>();
            private CLSMAESUB _selsubgrupo = new CLSMAESUB();

            private List<CLSFISICO> _invFisico = new List<CLSFISICO>();
            private CLSFISICO _selinvFisico = new CLSFISICO();

            private List<CLSFISICO> invFisico = new List<CLSFISICO>();

            private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();

            private Boolean _logExisteInvFis = false;

        #endregion

        #region Interfaces Publicas
            
            private string _strTituloVentana;
            public string strTituloVentana
            {
                get { return _strTituloVentana; }
                set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
            }

            public Boolean logExisteInvFis
            {
                get { return _logExisteInvFis; }
                set { _logExisteInvFis = value; base.OnPropertyChanged("logExisteInvFis"); }
            }

            public List<CLSMAEGRP> grupos
            {
                get { return _grupos; }
                set { _grupos = value; base.OnPropertyChanged("grupos"); }
            }

            public CLSMAEGRP selgrupo
            {
                get { return _selgrupo; }
                set 
                {
                    _selgrupo = value; 
                    base.OnPropertyChanged("selgrupo");
                    llenarSubgrupos();
                  
                    consultaInventarioFisico();
                }
            }

            public List<CLSMAESUB> subgrupos
            {
                get { return _subgrupos; }
                set { _subgrupos = value; base.OnPropertyChanged("subgrupos"); }
            }

            public CLSMAESUB selsubgrupo
            {
                get { return _selsubgrupo; }
                set 
                { 
                    _selsubgrupo = value; 
                    base.OnPropertyChanged("selsubgrupo");
                       consultaInventarioFisico();
        
                }
            }

            public CLSFISICO selinvFisico
            {
                get { return _selinvFisico; }
                set { _selinvFisico = value; base.OnPropertyChanged("selinvFisico"); }
            }

            private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
            public MDOgeneral.mensaje msn
            {
                get { return _msn; }
                set { _msn = value; base.OnPropertyChanged("msn"); }
            }

            private ObservableCollection<VMfisico> _lisfisico = new ObservableCollection<VMfisico>();
            public ObservableCollection<VMfisico> lisFisico
            {
                get { return _lisfisico; }
                set { _lisfisico = value; base.OnPropertyChanged("lisFisico"); }
            }

            private VMfisico _selFisico;
            public VMfisico selFisico
            {
                get { return _selFisico; }
                set
                {

                    if (_selFisico == null)
                        _selFisico = value;

                    if (_selFisico == null)
                        return;

                    if (_selFisico.logCantidadValida)
                        _selFisico = value;

                    base.OnPropertyChanged("selFisico");
                }
            }

            private Boolean _logValido = false;
            public Boolean logValido {
                get { return _logValido; }
                set { _logValido = value;
                base.OnPropertyChanged("logValido");
                }
            }

            private Boolean _logIsHidenInvFis = false;
            public Boolean logIsHidenInvFis 
            {
                get { return _logIsHidenInvFis; }
                set 
                { 
                    _logIsHidenInvFis = value;
                    logIsHidenComparativo = !_logIsHidenInvFis;
                    base.OnPropertyChanged("logIsHidenInvFis"); 
                }
            }
        
            private Boolean _logIsHidenComparativo = true;
            public Boolean logIsHidenComparativo
            {
                get { return _logIsHidenComparativo; }
                set { _logIsHidenComparativo = value; base.OnPropertyChanged("logIsHidenComparativo"); }
            }

            private List<VMComparativo> _lisComparativo = new List<VMComparativo>();
            public List<VMComparativo> lisComparativo
            {
                get { return _lisComparativo; }
                set { _lisComparativo = value; base.OnPropertyChanged("lisComparativo"); }
            }

            private VMComparativo _selComparativo;
            public VMComparativo selComparativo
            {
                get { return _selComparativo; }
                set
                {
                    if (_selComparativo == null)
                        _selComparativo = value;

                    if (_selComparativo == null)
                        return;

                    base.OnPropertyChanged("selComparativo");
                }
            }



        #endregion

        #region Comandos

            RelayCommand _cmdGenerar;
            public ICommand cmdGenerar
            {
                get
                {
                    if (_cmdGenerar == null)
                    {
                        _cmdGenerar = new RelayCommand(param => this.generar() );
                    }
                    return _cmdGenerar;
                }
            }

            RelayCommand _cmdSalir;
            public ICommand cmdSalir
            {
                get
                {
                    if (_cmdSalir == null)
                    {
                        _cmdSalir = new RelayCommand(Salir);
                    }
                    return _cmdSalir;
                }
            }

            RelayCommand _cmdGrabar;
            public ICommand cmdGrabar
            {
                get
                {
                    if (_cmdGrabar == null)
                    {
                        _cmdGrabar = new RelayCommand(param => this.grabar());
                    }
                    return _cmdGrabar;
                }
            }

            RelayCommand _cmdComparar;
            public ICommand cmdComparar
            {
                get
                {
                    if (_cmdComparar == null)
                    {
                        _cmdComparar = new RelayCommand(param => this.comparar());
                    }
                    return _cmdComparar;
                }
            }

            RelayCommand _cmdFinalizar;
            public ICommand cmdFinalizar
            {
                get
                {
                    if (_cmdFinalizar == null)
                    {
                        _cmdFinalizar = new RelayCommand(param => this.finalizar());
                    }
                    return _cmdFinalizar;
                }
            }    

            RelayCommand _cmdVerFisico;
            public ICommand cmdVerFisico
            {
                get
                {
                    if (_cmdVerFisico == null)
                    {
                        _cmdVerFisico = new RelayCommand(param => this.VerFisico());
                    }
                    return _cmdVerFisico;
                }
            }

            RelayCommand _cmdImprimir;
            public ICommand cmdImprimir
            {
                get
                {
                    if (_cmdImprimir == null)
                    {
                        _cmdImprimir = new RelayCommand(param => this.imprimir());
                    }
                    return _cmdImprimir;
                }
            }

            RelayCommand _cmdExcel;
            public ICommand cmdExcel
            {
                get
                {
                    if (_cmdExcel == null)
                    {
                        _cmdExcel = new RelayCommand(x => this.exportarExcel());
                    }
                    return _cmdExcel;
                }
            }

            #endregion

        #region Metodos
            
            public VMInventarioFisico()
            {
                try
                {
                    llenarGrupos();
                    logExisteInvFis = !_repositorio.consultaExisteInvFis();

                    if (!logExisteInvFis)
                    {
                        consultaInventarioFisico();
                    }

                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Inventario físico - Usuario: " + MDOgeneral.usuario + " - [FRMInventarioFisico]";

                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void llenarGrupos()
            {
                try
                {
                    grupos = new CLSMAEGRP().listaGrupos();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void llenarSubgrupos()
            {
                try
                {

                    if (selgrupo == null)
                    {
                        selsubgrupo = null;
                        subgrupos=new List<CLSMAESUB>();
                    }
                    else
                    {

                        subgrupos = new List<CLSMAESUB>();
                        CLSMAESUB grupo = new CLSMAESUB();
                        grupo.CODGRP_SUB = selgrupo.CODGRP_GRP;
                        subgrupos = grupo.listaSubg();
                    }

                    
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void consultaInventarioFisico()
            {
                try
                {
                    invFisico = _repositorio.consultarInventarioFisico(_selgrupo, _selsubgrupo);
                    List<VMfisico> all = (from cust in invFisico select new VMfisico(cust)).ToList();
                    foreach (VMfisico cvm in all)
                        cvm.validarcoleccion += ValidateColeccion;
                    lisFisico = new ObservableCollection<VMfisico>(all);
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void generar()
            {
                try
                {
                    if (_repositorio.generarInventarioFisico())
                    {
                        consultaInventarioFisico();

                        msn.texto = "Inventario físico generado con exito.";
                        msn.tipo = true;
                    }
                    else
                    {
                        msn.texto = "El inventario Físico no se pudo generar.";
                        msn.tipo = false;
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void grabar()
            {
                try
                {
                    cargarModelo();
                    if (_repositorio.grabarInventarioFisico(_invFisico))
                    {
                        msn.texto = "Inventario físico se grabo con exito.";
                        msn.tipo = true;
                    }
                    else
                    {
                        msn.texto = "El inventario Físico no se pudo grabar.";
                        msn.tipo = false;
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void finalizar()
            {
                try
                {
                    if (_repositorio.finalizarInventarioFisico())
                    {
                        msn.texto = "Inventario físico finalizado con exito.";
                        msn.tipo = true;
                    }
                    else
                    {
                        msn.texto = "El inventario Físico no se pudo finalizar.";
                        msn.tipo = false;
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void VerFisico() 
            {
                try 
                {
                    logIsHidenInvFis = false;
                    lisComparativo.Clear();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void comparar()
            {
                try
                {
                    logIsHidenInvFis = true;

                    List<CLSFISICO> all = _repositorio.compararInventarioFisico(_selgrupo, _selsubgrupo);
                    lisComparativo.Clear();
                    lisComparativo = (from cust in all select new VMComparativo(cust)).ToList();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void exportarExcel()
            {
                try
                {
                    Mouse.OverrideCursor = Cursors.Wait;

                    Color colorTitulo = Color.FromArgb(10, 75, 172, 198);

                    // Crea los objetos de excel, el libro y la hoja nueva de excel
                    var objExcel = default(Excel.Application);
                    var objLibro = default(Excel.Workbook);
                    var objHoja = default(Excel.Worksheet);
                    
                    // Crea la instancia de excel y agrega un nuevo libro y una nueva hoja
                    objExcel = new Excel.Application();
                    objLibro = objExcel.Workbooks.Add();
                    objHoja = objLibro.Worksheets[1];

                    //Agrega el titulo a la hoja
                    objHoja.Range["A1:H1"].Merge();
                    objHoja.Range["A1:H1"].Value = "Artesa S.A.S  Informe Inventario Físico";
                    objHoja.Range["A1:H1"].Font.Bold = true;
                    objHoja.Range["A1:H1"].Font.Size = 14;

                    //Centra el titulo 
                    Excel.Range objRango1 = objExcel.Range["A1:H1"];
                    objRango1.Select();
                    objRango1.HorizontalAlignment = 3;
                    objRango1.VerticalAlignment = 3;

                    // Crea un objeto para manejar las celdas
                    Excel.Range objCelda = objExcel.Range["A6", Type.Missing];

                    //Agrega la fecha y los parametros del formulario
                    objCelda = objExcel.Range["G3", Type.Missing];
                    objCelda.Value = "Fecha:";
                    objCelda = objExcel.Range["H3", Type.Missing];
                    objCelda.Value = DateTime.Now;

                    objCelda = objExcel.Range["A3", Type.Missing];
                    objCelda.Value = "Grupo:";
                    if (selgrupo.CODGRP_GRP != null)
                    {
                        objCelda = objExcel.Range["B3", Type.Missing];
                        objCelda.Value = selgrupo.NOMGRP_GRP.Trim();
                    }

                    objCelda = objExcel.Range["A4", Type.Missing];
                    objCelda.Value = "SubGrupo:";
                    if (selsubgrupo.CODGRP_SUB != null)
                    { 
                        objCelda = objExcel.Range["B4", Type.Missing];
                        objCelda.Value = selsubgrupo.NOMSUB_SUB.Trim();
                    }

                    //Le ponemos negrita a los titulos de los parametros
                    Excel.Range objRango = objExcel.Range["A3:A4"];
                    objRango.Font.Size = 12;
                    objRango.Font.Bold = true;

                    objRango = objExcel.Range["G3:G3"];
                    objRango.Font.Size = 12;
                    objRango.Font.Bold = true;


                    // agrega los titulos de las celdas
                    objCelda = objExcel.Range["A6", Type.Missing];
                    objCelda.Value = "Material";

                    objCelda = objExcel.Range["B6", Type.Missing];
                    objCelda.Value = "Nombre Material";

                    objCelda = objExcel.Range["C6", Type.Missing];
                    objCelda.Value = "Color";

                    objCelda = objExcel.Range["D6", Type.Missing];
                    objCelda.Value = "Nombre Color";

                    objCelda = objExcel.Range["E6", Type.Missing];
                    objCelda.Value = "Unidad Uso";

                    objCelda = objExcel.Range["F6", Type.Missing];
                    objCelda.Value = "Cantidad Física";

                    objCelda = objExcel.Range["G6", Type.Missing];
                    objCelda.Value = "Grupo";

                    objCelda = objExcel.Range["H6", Type.Missing];
                    objCelda.Value = "Subgrupo";

                    objRango = objExcel.Range["A6:H6"];
                    objRango.Font.Size = 12;
                    objRango.Font.Bold = true;

                    // Llena la tabla de excel con los datos
                    int i = 7;
                    foreach (VMfisico fis in lisFisico)
                    {
                        objExcel.Cells[i, "A"] = fis.codmat_fis;
                        objExcel.Cells[i, "B"] = fis.nommat_fis;
                        objExcel.Cells[i, "C"] = fis.codcol_mat;
                        objExcel.Cells[i, "D"] = fis.nomcol_fis;
                        objExcel.Cells[i, "E"] = fis.uniusu_fis;
                        objExcel.Cells[i, "F"] = fis.canfis_fis;
                        objExcel.Cells[i, "G"] = fis.codgrp_fis;
                        objExcel.Cells[i, "H"] = fis.codsub_fis;

                        i++;
                    }

                    // Creamos un objeto rango para poner formato a las celdas
                    objRango = objExcel.Range["F6:F" + (i+100).ToString()];
                    objRango.Select();
                    objRango.NumberFormat = "_(* #,##0.00_);_(* (#,##0.00);_(* 0_);_(@_)";

                    objRango = objExcel.Range["A6:E" + (i - 1).ToString()];
                    objRango.Select();
                    objRango.NumberFormat = "@";

                    objRango = objExcel.Range["G6:H" + (i - 1).ToString()];
                    objRango.Select();
                    objRango.NumberFormat = "@";
                    
                    objRango = objExcel.Range["A6:H" + (i - 1).ToString()];
                    objRango.Columns.AutoFit();
                    objRango.AutoFilter(1);

                    // Abre el excel
                    objExcel.Visible = true;

                    Mouse.OverrideCursor = Cursors.Arrow;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void imprimir()
            {
                try
                {
                    if (!logIsHidenInvFis)
                    {
                        DataTable dtImp = new DataTable("dtInvFisico");
                        dtImp.Columns.Add("CODMAT_FIS");
                        dtImp.Columns.Add("NOMMAT_FIS");
                        dtImp.Columns.Add("CODCOL_FIS");
                        dtImp.Columns.Add("NOMCOL_FIS");
                        dtImp.Columns.Add("UNIUSO_FIS");
                        dtImp.Columns.Add("CANFIS_FIS");
                        dtImp.Columns.Add("CODGRP_FIS");
                        dtImp.Columns.Add("CODSUB_FIS");

                        DataRow dr;
                        foreach (VMfisico i in lisFisico)
                        {
                            dr = dtImp.NewRow();
                            dr["CODMAT_FIS"] = i.codmat_fis;
                            dr["NOMMAT_FIS"] = i.nommat_fis;
                            dr["CODCOL_FIS"] = i.codcol_mat;
                            dr["NOMCOL_FIS"] = i.nomcol_fis;
                            dr["UNIUSO_FIS"] = i.uniusu_fis;
                            dr["CANFIS_FIS"] = Convert.ToDouble(i.canfis_fis);
                            dr["CODGRP_FIS"] = i.codgrp_fis;
                            dr["CODSUB_FIS"] = i.codsub_fis;

                            dtImp.Rows.Add(dr);
                        }

                        DataSet ds = new DataSet("dsInvFisico");
                        ds.Tables.Add(dtImp);

                        Vista vista = new Vista { ds = ds, reporte = @"reportes\rptInvFisico.rpt" };
                        vista.Show();
                    }
                    else
                    {
                        DataTable dtc = new DataTable("dtComparativo");
                        dtc.Columns.Add("CODMAT_FIS");
                        dtc.Columns.Add("CODCOL_FIS");
                        dtc.Columns.Add("NOMMAT_FIS");
                        dtc.Columns.Add("NOMCOL_FIS");
                        dtc.Columns.Add("CANFIS_FIS");
                        dtc.Columns.Add("eximtp_mtp");
                        dtc.Columns.Add("Diferencia");

                        DataRow drc;
                        foreach (VMComparativo c in lisComparativo)
                        {
                            drc = dtc.NewRow();
                            drc["CODMAT_FIS"] = c.codmat_fis;
                            drc["CODCOL_FIS"] = c.codcol_fis;
                            drc["NOMMAT_FIS"] = c.nommat_fis;
                            drc["NOMCOL_FIS"] = c.nomcol_fis;
                            drc["CANFIS_FIS"] = c.canfis_fis;
                            drc["eximtp_mtp"] = c.numTeorico;
                            drc["Diferencia"] = c.numDiferencia;

                            dtc.Rows.Add(drc);
                        }

                        DataSet dsc = new DataSet("dsComparativo");
                        dsc.Tables.Add(dtc);

                        Vista vista = new Vista { ds = dsc, reporte = @"reportes\rptComparativo.rpt" };
                        vista.Show();
                    }

                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void Salir(Object frmformulario)
            {
                ((Window)frmformulario).Close();
            }

            public void ValidateColeccion() {
                try 
                {
                    logValido = !lisFisico.Any(x => x.IsValid == false);
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void cargarModelo() 
            {
                try 
                {
                    _invFisico = new List<CLSFISICO>();
                    _invFisico = (from cust in lisFisico where cust.canfis_fis!=cust.numfisico select cust.getFisico()).ToList();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }   

        #endregion

        #region Eventos
            
        #endregion

        #region IDataErrorInfo Members

            string IDataErrorInfo.Error { get { return null; } }

            string IDataErrorInfo.this[string propertyName]
            {
                get { return this.GetValidationError(propertyName); }
            }

        #endregion

        #region Validation

            /// <summary>
            /// Returns true if this object has no validation errors.
            /// </summary>
            public bool IsValid
            {
                get
                {
                    foreach (string property in ValidatedProperties)
                        if (GetValidationError(property) != null)
                            return false;

                    return true;
                }
            }

            static readonly string[] ValidatedProperties = 
            { 
                "selgrupo",
                "selsubgrupo"
            };

            string GetValidationError(string propertyName)
            {
                if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                    return null;

                string error = null;

                switch (propertyName)
                {
                    case "selgrupo":
                        error = this.Validatedselgrupo();
                        break;
                    case "selsubgrupo":
                        error = this.Validatedselsubgrupo();
                        break;
                    default:
                        Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                        break;
                }
                return error;
            }

            string Validatedselgrupo()
            {
                if (selgrupo == null)
                {
                    return "Debe seleccionar un grupo.";
                }
                return null;
            }

            string Validatedselsubgrupo()
            {
                if (selsubgrupo == null)
                {
                    return "Debe seleccionar un subgrupo.";
                }
                return null;
            }

        #endregion

        #region Vista modelos

            public class VMfisico : ViewModelBase, IDataErrorInfo
            {
                #region campos
                    private CLSFISICO _fisico = new CLSFISICO();
                    private ProcesoProduccionRepositorio _rep = new ProcesoProduccionRepositorio();
                    public double numfisico { get; set; }
                #endregion

                #region constructor

                    public VMfisico(CLSFISICO fisico)
                    {
                        _fisico = fisico;
                        numfisico = _fisico.CANFIS_FIS;
                        
                    }

                #endregion

                #region metodos

                    public CLSFISICO getFisico()
                    {
                        return _fisico;
                    }

                    public delegate void ValidateColeccion();

                #endregion

                #region interfaces publicas

                
                    public ValidateColeccion validarcoleccion { get; set; }

                    public string codmat_fis
                    {
                        get { return _fisico.CODMAT_FIS; }
                        set { _fisico.CODMAT_FIS = value; base.OnPropertyChanged("codmat_fis"); }
                    }

                    public string codcol_mat
                    {
                        get { return _fisico.CODCOL_FIS; base.OnPropertyChanged("codcol_fis"); }
                    }

                    public string nommat_fis
                    {
                        get { return _fisico.NOMMAT_FIS; }
                        set { _fisico.NOMMAT_FIS = value; base.OnPropertyChanged("nommat_fis"); }
                    }

                    public string nomcol_fis
                    {
                        get { return _fisico.NOMCOL_FIS; }
                        set { _fisico.NOMCOL_FIS = value; base.OnPropertyChanged("nomcol_fis"); }
                    }

                    public string uniusu_fis
                    {
                        get { return _fisico.UNIUSO_FIS; }
                        set { _fisico.UNIUSO_FIS = value; base.OnPropertyChanged("uniusu_fis"); }
                    }

                    public double canfis_fis
                    {
                        get { return _fisico.CANFIS_FIS; }
                        set { _fisico.CANFIS_FIS = value; base.OnPropertyChanged("canfis_fis"); }
                    }

                    public string codgrp_fis
                    {
                        get { return _fisico.CODGRP_FIS; }
                        set { _fisico.CODGRP_FIS = value; base.OnPropertyChanged("codgrp_fis"); }
                    }

                    public string codsub_fis
                    {
                        get { return _fisico.CODSUB_FIS; }
                        set { _fisico.CODSUB_FIS = value; base.OnPropertyChanged("codsub_fis"); }
                    }
        

                    private Boolean _logCantidadValida = true;
                    public Boolean logCantidadValida
                    {
                        get { return _logCantidadValida; }
                        set { _logCantidadValida = value; base.OnPropertyChanged("logCantidadValida"); }
                    }

                #endregion

                #region IDataErrorInfo Members

                string IDataErrorInfo.Error { get { return null; } }

                string IDataErrorInfo.this[string propertyName]
                {
                    get { return this.GetValidationError(propertyName); }
                }

                #endregion

                #region Validation

                    /// <summary>
                    /// Returns true if this object has no validation errors.
                    /// </summary>
                    /// 

                    private bool _IsValid;
                    public bool IsValid
                    {
                        get
                        {
                            foreach (string property in ValidatedProperties)
                                if (GetValidationError(property) != null)
                                    return false;
                            return true;
                        }
                        set {
                            _IsValid = value;
                            base.OnPropertyChanged("IsValid");
                            validarcoleccion();
                        }
                    }

                    static readonly string[] ValidatedProperties = 
                    { 
                        "canfis_fis"
                    };

                    string GetValidationError(string propertyName)
                    {
                        if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                            return null;

                        string error = null;

                        switch (propertyName)
                        {
                            case "canfis_fis":
                                error = this.Validatecanfis_fis();
                                break;
                            default:
                                Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                                break;
                        }
                        return error;
                    }

                    string Validatecanfis_fis()
                    {
                        double _numCantidad = Convert.ToDouble(canfis_fis);
                        if (_numCantidad < 0 )
                        {
                            return "El valor ingresado no es valido.";
                        }
                        return null;
                    }

                #endregion

            }

            public class VMComparativo : ViewModelBase
            {
                #region campos
                private CLSFISICO _comparativo = new CLSFISICO();
                private ProcesoProduccionRepositorio _rep = new ProcesoProduccionRepositorio();
               
                #endregion

                #region constructor

                public VMComparativo(CLSFISICO comparativo)
                {
                    _comparativo = comparativo;
                    numDiferencia = _comparativo.CANFIS_FIS - _comparativo.maeMtp.EXIMTP_MTP;
                }

                #endregion

                #region metodos

                public CLSFISICO getcomparativo()
                {
                    return _comparativo;
                }

                #endregion

                #region interfaces publicas

                public string codmat_fis
                {
                    get { return _comparativo.CODMAT_FIS; }
                    set { _comparativo.CODMAT_FIS = value; base.OnPropertyChanged("codmat_fis"); }
                }

                public string codcol_fis
                {
                    get { return _comparativo.CODCOL_FIS; }
                    set { _comparativo.CODCOL_FIS = value; base.OnPropertyChanged("codcol_fis"); }
                }

                public string nommat_fis
                {
                    get { return _comparativo.NOMMAT_FIS; }
                    set { _comparativo.NOMMAT_FIS = value; base.OnPropertyChanged("nommat_fis"); }
                }

                public string nomcol_fis
                {
                    get { return _comparativo.NOMCOL_FIS; }
                    set { _comparativo.NOMCOL_FIS = value; base.OnPropertyChanged("nomcol_fis"); }
                }

                public double canfis_fis
                {
                    get { return _comparativo.CANFIS_FIS; }
                    set { _comparativo.CANFIS_FIS = value; base.OnPropertyChanged("canfis_fis"); }
                }

                public double numTeorico
                {
                    get { return _comparativo.maeMtp.EXIMTP_MTP; }
                    set { _comparativo.maeMtp.EXIMTP_MTP = value; base.OnPropertyChanged("numTeorico"); }
                }

                private double _numDiferencia;
                public double numDiferencia
                {
                    get { return _numDiferencia; }
                    set { _numDiferencia = value; base.OnPropertyChanged("numDiferencia"); }
                }

                #endregion

            }

        #endregion


    }
}
